\chapter{Getting started with {\dalton}}\label{ch:starting}

In this chapter we give an introduction to the input files needed
for doing a calculation with the {\dalton} program. The program executable reads input
from \dalinp\ \index{DALTON.INP} (specifies what is calculated), \molinp\ \index{MOLECULE.INP} (gives
the molecule including basis set information and more) and \potinp\ \index{POTENTIAL.INP} (provides the embedding potential and only needed for
embedding calculations). We also introduce the \verb|dalton| shell script,
that is supplied with the program, for moving the relevant files to the
scratch-directory and back to the home directory after a calculation has completed.
Using the \verb|dalton| script allows more flexible naming of the input files because the script will rename them from \verb|input.dal| to \dalinp, \verb|input.mol| to \molinp\ and \verb|input.pot| to \potinp, where \verb|input| can be freely specified by the user.
A couple of examples of input files are also provided. Finally, the different output
files generated by the program are discussed.

\section{The \molinp\ input file}

We will not go into great detail here of the input format of the \molinp\ \index{MOLECULE.INP} file, as it is treated thoroughly in a separate chapter,
Chapter~\ref{ch:molinp}.
Here we only present two inputs for water; one
using Cartesian coordinate\index{Cartesian coordinates} input and
automatic symmetry detection\index{symmetry!automatic detection}, and
the other using Cartesian coordinates and where we explicitly give the
symmetry elements. Finally we show the input for H$_{2}$O$^{2+}$
using Z-matrix input\index{Z-matrix input}. In
all cases the basis set library of {\dalton} has been used, as we
assume that most users will exploit the basis sets provided in the basis
set library as opposed to entering them directly in the \molinp\ file. The format for basis sets are described in detail in Sec.~\ref{sec:molcart}.

Let us first start with an input for water using Cartesian coordinates
in \bohr{}, and the very popular 6-31G** basis set.

\begin{verbatim}
BASIS
6-31G**
 Water using the 6-31G** basis
 Using automatic symmetry detection.
Atomtypes=2
Charge=8.0 Atoms=1
O      .0000000000        -.2249058930         .0000000000
Charge=1.0 Atoms=2
H_a   1.4523499293         .8996235720         .0000000000
H_b  -1.4523499293         .8996235720         .0000000000
\end{verbatim}


On the fifth line the number of different atom types or more correctly,
the number of  blocks of atoms,
in this case two, oxygen and hydrogen, are given. There are one oxygen with
charge 8, and two hydrogens with charge 1. The symmetry of the system
will be detected by the program during the input processing unless
turned off as shown in the last of the input examples for the \molinp\
input files.

We may also add the symmetry elements\index{symmetry!element} of the
symmetry group\index{symmetry!group} ourselves. We must
then remove all symmetry-dependent centers\index{symmetry-dependent center}. For the above input this
will result in, if we use reflections in the yz-plane (the $x$ axis changes sign during this
symmetry operation) and the xz-plane (the $y$ axis changes sign) as the symmetry generators: 

\begin{verbatim}
ATOMBASIS
 Water using ANOs specified for each atomtype
 Standard orientation: C2-rotation along z-axis, molecule in yz-plane
Atomtypes=2 Generators=2 X Y
Charge=8.0 Atoms=1 Basis=ano-1 5 4 3 1
O      .0000000000         .0000000000        -.2249058930
Charge=1.0 Atoms=1 Basis=ano-1 4 3 2
H_a    .0000000000        1.4523499293         .8996235720
\end{verbatim}

In the above calculation we used the ANO set\index{ANO basis set} of
Widmark and
coworkers~\cite{powpambortca77,powbjpbortca79}.
We use the contractions
[5s4p3d1f/4s3p2d] for the oxygen and the hydrogens respectively. We
also note the keyword \verb|ATOMBASIS|\index{ATOMBASIS} which allows
different basis functions to be used on different atoms.

Let us now proceed to an input for H$_{2}$O$^{2+}$ where we use
Z-matrix input\index{Z-matrix input}. This will then look like:

\begin{verbatim}
BASIS
Sadlej-pVTZ
 Water - geometry optimization with Sadlej's basis set
 Project - Raman
Atomtypes=3 Charge=2 Nosymmetry
ZMAT
O   1 8.0
H   2 1 0.97 1.0
H   3 1 0.97 2 104.5 1.0
\end{verbatim}

In addition to the number of atoms in the input (3), we have given the
total charge\index{molecular charge} of the
molecule ($+2$), and the keyword \verb|Nosymmetry| indicates that
symmetry is not to be used in this calculation. Note that
unlike Cartesian coordinate input, which by default is in atomic units, the
Z-matrix input is always to be in \angstrom{}.

\section{The \dalinp\ input file}\label{sec:daltoninp}

The \dalinp\ file contains the keywords telling the program
what kind of atomic integrals\index{atomic integrals} are wanted
({\her}, in the \Sec{*INTEGRALS} input module), what kind of wave
function\index{wave function} is to be used ({\sir}, in the
\Sec{*WAVE FUNCTIONS} input
module), what kind of molecular properties \index{molecular properties} are
to be evaluated (\aba , in the \Sec{*PROPERTIES} input module), and
finally which response functions\index{response function} that are to
be evaluated (\resp , in
the \Sec{*RESPONSE} input module).

This input file is described in detail in several of the subsequent chapters,
and we will  only give a few examples of input files here and shortly
explain what they do, in order to give the user a flavor of the input
and the computational possibilities
of {\dalton}.

\subsection{A CASSCF geometry optimization}

We start by a simple geometry optimization\index{geometry optimization} 
of a water molecule using a Complete 
Active Space (CAS)\index{CASSCF} wave function, where we use C$_{2v}$ symmetry
keeping the 1s orbital on oxygen inactive and distributing the valence
electrons  into 8 orbitals. At the starting geometry we
evaluate the nuclear magnetic shielding constants\index{nuclear shielding} 
and the magnetizability\index{magnetizability} of the water
molecule, and at the optimized geometry we perform a vibrational
analysis\index{vibrational analysis} and calculate the IR
intensities\index{IR intensity}\index{dipole gradient}\index{atomic polar tensor}\index{APT} 
(related to the dipole
gradient). The input file for such a calculation will look like:

\begin{verbatim}
**DALTON INPUT         Must start all input files
.OPTIMIZE              Request geometry optimization
**WAVE FUNCTIONS       Wave function input
.HF                    We start with HF
.MP2                   Then MP2 (starting orb. for MCSCF)
.MCSCF                 Request an MCSCF
*SCF INPUT             HF input
.DOUBLY OCCUPIED
 3 1 1 0
*CONFIGURATION INPUT   Input of active space
.SYMMETRY              Wave function symmetry
 1
.SPIN MULTIPLICITY
 1                     Singlet
.INACTIVE              Doubly occupied orbitals
 1 0 0 0               1s on oxygen
.CAS SPACE
 4 2 2 0
.ELECTRONS             Number of electrons to correlate
 8                     The valence electrons
**START                Input for start geometry
.SHIELD                Nuclear shieldings
.MAGNET                Magnetizability
**PROPERTIES           Input for optimized geometry
.DIPGRA                Dipole gradient
.VIBANA                Vibrational analysis
**END OF DALTON INPUT
\end{verbatim}

\subsection{A RASSCF calculation of NMR parameters}

The next input file gives an example of the input needed for
evaluating the two parameters determining an NMR spectrum, the nuclear
shielding\index{nuclear shielding} constants and the spin--spin
coupling constants\index{spin-spin coupling}. We do this
at a fixed geometry, and use a Restricted Active Space (RAS)\index{RASSCF} wave
function. In this way we include near-degeneracy\index{near degeneracy} effects by inclusion
of the appropriate orbitals in the RAS2 space, and also some of the
dynamical correlation\index{dynamical correlation}  by single and
double excitations
from the RAS2 space (and generally also form the RAS1 space) into the
RAS3 space.

In this input we once more use water as input molecule,
where we keep
the 1s orbital inactive, correlate 8 electrons in 6 orbitals (full valence
CAS) and in addition allow single- and double-excitations into
7 additional orbitals.
The order of the irreps is assumed to be $a_1 b_1 b_2 a_2$, as it will be if automatic symmetry detection is used.
(The user can enforce another order of the irreps if explicity symmetry input is used in the .mol file.)

\begin{verbatim}
**DALTON INPUT
.RUN PROPERTIES        Run integrals, wave function and properties
**WAVE FUNCTIONS
.HF
.MP2
.MCSCF
*SCF INPUT
.DOUBLY OCCUPIED
 3 1 1 0
*CONFIGURATION INPUT
.SYMMETRY
 1
.SPIN MUL
 1
.INACTIVE
 1 0 0 0
.RAS1 SPACE            # orbitals in RAS1 space
 0 0 0 0
.RAS2 SPACE            The ``full valence CAS Space''
 3 1 2 0               for symmetry order a1 b1 b2 a2
.RAS3 SPACE
 3 2 1 1               for symmetry order a1 b1 b2 a2
.ELECTRONS             Number of electrons to correlate
 8                     The valence electrons
.RAS1 HOLES            # elect. that may be removed from RAS1
 0 0
.RAS3 ELECTRONS        From 0 to 2 electrons excited into RAS3
 0 2
**PROPERTIES           Input for single geometry run
.SHIELD
.SPIN-S
**END OF DALTON INPUT
\end{verbatim}

\subsection{A (parallel) cubic response calculation}\index{parallel calculation}

In this example of a \verb|DALTON.INP| file, we request an SCF
calculation of the second
hyperpolarizability\index{second hyperpolarizability}
($\gamma_{xxxx}$) using
the cubic response solver\index{cubic response}\index{response!cubic}
of the {\resp} module. Such calculations are well suited for parallel runs
which require that the program has been compiled with MPI options. No extra
keywords are necessary since the \dalton\ program will run in parallel if there are more than one processes available at runtime. This is determined when
submitting the job, and how this is done depends on the computer on which the
job is run. Running in parallel will result in a direct calculation, i.e.\
no two-electron integrals will be stored on disk in any part of the
calculation. To run direct in serial calculations it is necessary to add the \Key{DIRECT} keyword.

All treatment  of symmetry, as well as the Hartree--Fock
occupation,\index{HF occupation}\index{Hartree--Fock occupation} is
automatically taken care of by the program, and we thus only need to
specify that we are to do a Hartree--Fock calculation.

\begin{verbatim}
**DALTON INPUT
.RUN RESPONSE          Run integrals, wave function, and response
.DIRECT                Not required for parallel calculations
**WAVE FUNCTIONS
.HF
**RESPONSE             Input for the response module
*CUBIC                 Input for cubic response calculation
.DIPLNX                Only consider x-comp. of dipole moment
.BFREQ                 Two frequencies for B operator
 2
 0.0 0.0592            Frequencies in atomic units
.CFREQ                 One frequency for C operator
 1
 0.0
.DFREQ                 One frequency for D operator
 1
 0.0
.THCLR                 Threshold for linear response equations
 1.0D-5
**END OF DALTON INPUT
\end{verbatim}


\subsection{General structure of the \dalinp\ file}\label{sec:inputstructure}

The input is divided into modules\index{module}, which in turn are
further divided into submodules\index{submodule}. The modules contain
the input to the different
sections that constitute the {\dalton} program. There exists
four such sections corresponding to respectively the integral
evaluation\index{atomic integrals}, the choice of wave function, the
choice of static properties\index{molecular properties} and finally
the choice of dynamic properties\index{response}. For each of
these sections there exists a module with a name started by two stars,
that is:

\begin{verbatim}
**INTEGRALS

**WAVE FUNCTIONS

**PROPERTIES

**RESPONSE
\end{verbatim}

In addition there is a module controlling the {\dalton} program, which
has the input card \Sec{*DALTON}. All
input modules will be described in detail in separate chapters in the
Reference Manual (Chapter \ref{ch:general}---\ref{ch:CC}).

For geometry optimizations\index{geometry optimization},
different options may often be wanted for different stages of the
geometry optimization, and there exists three different \aba\ input
modules for geometry optimizations: \Sec{*START}, \Sec{*EACH STEP},
\Sec{*PROPERTIES}. \Sec{*START} gives input for the initial point,
\Sec{*EACH STEP} gives input options during the optimization of the
molecular geometry
(and for the initial point if no \Sec{*START} was specified and for
the final point if no \Sec{*PROPERTIES} was  given),
and \Sec{*PROPERTIES} gives input options for the
analysis that is to be done at the optimized geometry. In this way one
may start a calculation at an experimental geometry, evaluating a set
of molecular properties of interest, do an ordinary geometry
optimization without any properties evaluated during the geometry
optimization, and then recalculate the same set of molecular
properties (or others) at the optimized geometry in one single run. 
Note that if a \Sec{*RESPONSE} module is present in a geometry optimization,
the \resp\ calculations will only be performed at the optimized geometry. The input file must end with the keyword \Sec{*END OF}.

In a given module, several submodules\index{submodule} may be
specified, which determine the performance in various parts of the
calculation. The different input cards\index{input card} available
in the different submodules are started with a dot, {\it i.e.}~an input
option should be typed as \Key{IMAGE}. For most calculations the
default settings may be used. The authors have, however, always
opted for the largest degree of freedom, giving the user good
opportunities for tailoring an input to suit the needs of a given
calculation.

Even though we at times write large, self-explanatory keywords in this
manual, only the first seven characters (including the \verb|.| or
\verb|*|) are significant\index{significant characters} and will be
treated by the program. At any
place in the input, comments\index{comments} may be added using
\verb|#| or \verb|!|
in the first position of the command line. The input is case sensitive
and only upper-case characters will be recognized.

A general input structure for {\dalton} will look like

\begin{verbatim}
**DALTON INPUT
...
**INTEGRALS
...
**WAVE FUNCTIONS
...
*CONFIGURATION INPUT
...
**START
...
**EACH STEP
...
**PROPERTIES
...
**RESPONSE
...
**END OF DALTON INPUT
\end{verbatim}

Several submodules can of course be added in each of the above
modules. We restate that if \resp\ is requested in a geometry
optimization, the evaluation of the response functions will only be
done at the optimized geometry.

Examples of input files can be found in the various chapters
describing the calculation of different molecular properties, and
these chapters will probably be sufficient for most calculations done
with {\dalton}. However, all possible keywords are described in detail
in separate chapters in the Reference Manual (Chapter \ref{ch:general}---\ref{ch:CC}). The tests in the
\verb|DALTON/test| directory also serve to demonstrate how to run
different kinds of calculations using {\dalton}.

\section{The \potinp\ input file}

This file holds the embedding potential needed for a polarizable embedding
calculation (see Chapter~\ref{ch:embedding} for details). To demonstrate the
input format we use an example of a two-photon absorption (2PA) calculation
on acrolein and two water molecules, where the former is defined as the central core system treated using DFT and the two water molecules are described classically. The \molinp\ file we will use is
\begin{verbatim}
BASIS
STO-3G
Acrolein
------------------------
AtomTypes=3 NoSymmetry Angstrom
Charge=6.0 Atoms=3
C             -0.145335   -0.546770    0.000607
C              1.274009   -0.912471   -0.000167
C              1.630116   -2.207690   -0.000132
Charge=8.0 Atoms=1
O             -0.560104    0.608977    0.000534
Charge=1.0 Atoms=4
H             -0.871904   -1.386459    0.001253
H              2.004448   -0.101417   -0.000710
H              0.879028   -3.000685    0.000484
H              2.675323   -2.516779   -0.000673
\end{verbatim}
which is not different from any other (pure QM) calculation. The \dalinp\ file, however, needs additional input:
\begin{verbatim}
**DALTON
.RUN RESPONSE
.PELIB
**WAVE FUNCTIONS
.DFT
CAMB3LYP
**RESPONSE
*QUADRATIC
.TWO-PHOTON
.ROOTS
 4
**END OF
\end{verbatim}
Here we have specified that we want to calculate a response property 
(\Key{RUN RESPONSE}) using CAMB3LYP. The property we are after is a quadratic 
response property so we specify \Sec{QUADRATIC} under the \Sec{RESPONSE} 
section. We get the 2PA from the single residue of the quadratic response 
function and use the \Key{TWO-PHOTON} keyword to get those. In addition, we 
want the four lowest states, thus, we solve for four roots indicated by the 
\Key{ROOTS} keyword. The important point here is the \Key{PELIB} keyword which 
specifies that the core system (acrolein) is to be embedded in a (polarizable) environment given in the \potinp\ file:
\begin{verbatim}
! Two water molecules
@COORDINATES
10
AA
O   -3.3285510  -0.1032300  -0.0004160
H   -2.5037950   0.4132210   0.0003390
H   -4.0392140   0.5467290  -0.0008500
X   -2.9161730   0.1549955  -0.0000385
X   -3.6838825   0.2217495  -0.0006330
O    1.7422970   2.3413610  -0.0007450
H    0.8416780   1.9718070  -0.0008200
H    1.6325590   3.2983010   0.0041540
X    1.2919875   2.1565840  -0.0007825
X    1.6874280   2.8198310   0.0017045
@MULTIPOLES
ORDER 0
6
1   -0.74232
2    0.36993
3    0.37239
6   -0.74244
7    0.36996
8    0.37247
ORDER 1
10
1    0.03035   0.32807   0.00008
2   -0.10057  -0.05572  -0.00009
3    0.09115  -0.07296   0.00005
4   -0.11545  -0.10986  -0.00011
5    0.09255  -0.12819   0.00004
6   -0.28403   0.16718   0.00136
7    0.10391   0.04906   0.00004
8    0.00581  -0.11658  -0.00058
9    0.15621   0.02893  -0.00015
10   0.05016  -0.14938  -0.00082
ORDER 2
10
1   -3.95163  -0.05617   0.00083  -4.57788   0.00004  -5.02068
2   -0.57742  -0.05330  -0.00002  -0.60439  -0.00005  -0.55958
3   -0.55831   0.04666   0.00000  -0.62241   0.00002  -0.55829
4    0.69311   0.39938   0.00044   0.48117   0.00036   0.23354
5    0.54979  -0.40721   0.00016   0.63229  -0.00024   0.24194
6   -4.41881   0.28014   0.00021  -4.11299   0.00390  -5.02065
7   -0.64554  -0.00411   0.00014  -0.53625   0.00012  -0.55962
8   -0.55626   0.04501   0.00021  -0.62441  -0.00041  -0.55831
9    0.93099   0.22805  -0.00022   0.24298  -0.00039   0.23303
10   0.21761  -0.16639  -0.00076   0.96429   0.00386   0.24162
@POLARIZABILITIES
ORDER 1 1
10
1    1.59316   0.08008  -0.00121   2.52556   0.00134   3.36700
2    0.79298   0.15423   0.00015   0.60150   0.00028   0.59251
3    0.72094  -0.17834   0.00005   0.64202   0.00006   0.57514
4    3.49740   2.13550   0.00222   1.84555   0.00149   1.41243
5    2.69161  -2.24638   0.00033   2.55420  -0.00132   1.42933
6    2.28234  -0.42073  -0.00064   1.83243  -0.00690   3.36668
7    0.81327   0.13879   0.00041   0.58146  -0.00000   0.59279
8    0.49932  -0.01960   0.00005   0.86127   0.00201   0.57507
9    4.29463   1.26940   0.00040   1.05663  -0.00449   1.41332
10   0.61742  -0.44025  -0.00029   4.62200   0.01748   1.43071
EXCLISTS
10 5
1  2  3  4  5
2  1  3  4  5
3  1  2  4  5
4  1  2  3  5
5  1  2  3  4
6  7  8  9  10
7  6  8  9  10
8  6  7  9  10
9  6  7  8  10
10 6  7  8  9
\end{verbatim}
The \potinp\ file contains two water molecules described by distributed 
multipoles up to second order (i.e.\ quadrupoles) and dipole-dipole polarizabilities
located on atoms and bond-midpoints (the latter is indicated with \verb|X| in the \verb|@COORDINATES|
section). The potential parameters are obtained from separate calculations on each 
water molecule in vacuum and it is therefore also necessary to specify 
an exclusion list which specifies what other sites a given site can be polarized by.
More examples can be found in the \verb|DALTON/test| directory (search for 
\verb|PELIB|).

\section{The first calculation with {\dalton}}\label{sec:firstcalc}

If we have made two input files, one corresponding to
\dalinp\ \index{DALTON.INP} and one corresponding to the \molinp\
\index{MOLECULE.INP} input file, we
are ready to do our first calculation. Examples of input files can
also be found in the \verb|DALTON/test| directory hidden inside the
test jobs. You can execute one of the individual test jobs
without the \verb|TEST| script, for example:
\begin{verbatim}
> ./energy_nosymm
\end{verbatim}
This will create four files, but right now we are just interested in
the \verb|.dal| and the \verb|.mol| files. In this particular example
they will be \verb|energy_nosymm.dal| and
\verb|energy_nosymm.mol|. Have a look at some of these input files to
get a head-on start on running different kinds of {\dalton} jobs.

Calculations with {\dalton} is most conveniently done using the
supplied \verb|dalton| shell script\index{dalton shell script}.
The general usage of the \verb|dalton| script is as follows
\begin{verbatim}
> dalton [options] dalinp{.dal} [molinp{.mol} [potinp{.pot}]]
\end{verbatim}
where \verb|[]| indicates optional input and assuming \verb|dalton| is
available in your path.
Thus, to run a calculation of $\beta$ (first
hyperpolarizability)\index{first hyperpolarizability} 
with input available as \verb|beta.dal| on the HCl molecule, and with
molecule input available as \verb|hcl.mol|, you would type
\begin{verbatim}
> dalton beta hcl
\end{verbatim}
When the job is
finished, the output is copied back as \verb|beta_hcl.out|. If it is an embedding
calculation requiring also a potential input, e.g.\ \verb|water.pot|, it would be
\begin{verbatim}
> dalton 2pa acrolein water
\end{verbatim}
and the output would be \verb|2pa_acrolen_water.out|. In case that the dalton and molecule
input (and potential input) have the same name we may write \verb|dalton energy_nosymm|,
and the corresponding output file will be named \verb|energy_nosymm.out|. In addition, the 
program will create and copy back an archive file named \verb|beta_hcl.tar.gz|. This file 
contains, in tar'ed and gzip'ed form, a number of useful interface and
post-processing files needed for post-\dalton\ programs, or when
restarting calculations.

There are several options to this script,
which can be viewed by typing \verb| dalton -h| or just \verb|dalton|.
These options include:

\begin{list}{--}{}
\item[-b dir \hfill] \hfill \\
  Prepend 'dir' to the list of directories where the program
  should look for basis sets\index{basis set}. Needed in case you want to use
  local modifications of a given basis. The job directory and the \dalton\ basis set library will always be included in the basis set directory list
  (in that search order).
\item[-w dir \hfill] \hfill \\
  Change the working directory (\verb|WRKDIR|) to 'dir', that is,
  change the directory in which the program searches for input files
  and places the DALTON.OUT file to 'dir'. Default is to use current
  directory.
\item[-o file \hfill] \hfill \\
  Redirect the output normally printed in the
  DALTON.OUT file in the temporary directory
  to 'file' in the working
  directory. On a computer system with distributed scratch disk but a
  commonly mounted home directory, this allows you to follow the
  calculation without having to log into the compute nodes.
\item[-ow \hfill] \hfill \\
  Redirect the output normally printed in the
  DALTON.OUT file in the temporary directory
  to the working directory with standard file name.
\item[-ext log \hfill] \hfill \\
  Change the extension of the output file from .out to .log.
\item[-nobackup \hfill] \hfill \\
  Do not backup files. This option prevents backup of existing files in the working
  directory. Normally, existing files will be backed up and the filenames appended with
  .0, .1 and so on.
\item[-f dal\_mol(\_pot) \hfill] \hfill \\
  Copy and extract the tar.gz archive file containing a variety of useful
  interface files from your home directory to the scratch directory
  before a calculation starts. This is needed in order to be able to
  restart \dalton\ calculations, or if you want to use converged response
  vectors in a different response calculations for the same molecule.
\item[-noarch \hfill] \hfill \\
  Do not create the tar.gz archive file.
\item[-t tmpdir \hfill] \hfill \\
  Change the temporary/scratch directory (\verb|DALTON_TMPDIR|) to 'tmpdir' from the default scratch directory
  determined at runtime. This script will append \\
  '/DALTON\_scratch\_\$USER' to the path unless the path contains
  'DALTON\_scratch' or you use the -noappend option.
\item[-d \hfill] \hfill \\
  Removes the contents of the scratch directory before a
  calculation starts in order to avoid inconsistencies between files.
\item[-D \hfill] \hfill \\
  Do not remove the content of the scratch directory. By
  default the scratch directory will be deleted. However, in order to do
  a restart you may want to keep all files in this directory, and you
  then need to add the -D option when submitting the job.
\item[-noappend \hfill] \hfill \\
  Do not append anything to the scratch directory; be careful with
  this since by default scratch is wiped after calculation stops.
\item[-get "file1 file2 ..." \hfill] \hfill \\
  Get files from \verb|DALTON_TMPDIR| after calculation stops.
\item[-put "file1 file2 ..." \hfill] \hfill \\
  Put files to \verb|DALTON_TMPDIR| before calculation starts.
\item[-mb mb \hfill] \hfill \\
  Change the default size of the work memory\index{work memory}
  \index{scratch memory} to \verb|mb| Megabytes (only integer \verb|mb| allowed).
\item[-gb gb \hfill] \hfill \\
  Change the default size of the work memory\index{work memory}
  \index{scratch memory} to \verb|gb| Gigabytes (only integer \verb|gb| allowed).
\item[-mw mem \hfill] \hfill \\
  Change the default size of the work memory\index{work memory}
  \index{scratch memory} to \verb|mem| double precision words.
\item[-nmb mb \hfill] \hfill \\
  Change the default size of the node work memory\index{work memory}
  \index{scratch memory} to \verb|mb| Megabytes. Default: same as for master.
\item[-ngb gb \hfill] \hfill \\
  Change the default size of the node work memory\index{work memory}
  \index{scratch memory} to \verb|gb| Gigabytes. Default: same as for master.
\item[-nw mem \hfill] \hfill \\
  Change the default size of the node work memory\index{work memory}
  \index{scratch memory} to \verb|mem| double precision words. Default: same as for master.
\item[-omp num\hfill] \hfill \\
  Set the number of OpenMP threads to \verb|num|. Note that \dalton\ is not OpenMP
  parallelized, however, this option can be used with e.g.\ the
  threaded MKL or openBLAS libraries.
\item[-N num | -np num\hfill] \hfill \\
  Number of MPI processes to be used in a parallel MPI calculation
  controlled by running mpirun/mpiexec.
\item[-cpexe \hfill] \hfill \\
  Copy dalton.x to DALTON\_TMPDIR before execution, either to
  global scratch (if DALTON\_USE\_GLOBAL\_SCRATCH is set) or to
  local scratch on all nodes.
\item[-rsh \hfill] \hfill \\
  Use rsh/rcp for communications between cluster nodes (default ssh/scp)
\item[-nodelist "node1 node2 ..." \hfill] \hfill \\
  Set nodelist DALTON\_NODELIST, dalton.x will be copied to
  DALTON\_TMPDIR on each node unless DALTON\_USE\_GLOBAL\_SCRATCH
  is defined. The script uses PBS\_NODEFILE or SLURM\_NODELIST
  if available.
\item[-x dalmol1 dalmol2 \hfill] \hfill \\
  Calculate NEXAFS spectrum from ground and core hole states
\end{list}

Furthermore, the \verb|dalton| script uses the following environment
variables:

\begin{list}{--}{}
\item[DALTON\_TMPDIR \hfill] \hfill \\
 Scratch directory.
\item[DALTON\_USE\_GLOBAL\_SCRATCH \hfill] \hfill \\
 Use global scratch directory, do not copy any files to worker nodes.
\item[DALTON\_NODELIST \hfill] \hfill \\
 List of nodes, dalton.x will be copied to DALTON\_TMPDIR on each node unless DALTON\_USE\_GLOBAL\_SCRATCH is defined.
\item[DALTON\_LAUNCHER \hfill] \hfill \\
 Launcher for the dalton.x binary.
 It is not allowed to use -N or -np together with DALTON\_LAUNCHER, instead the number of MPI processes
 must be specified in the DALTON\_LAUNCHER specification.
 Specification of DALTON\_LAUNCHER is the only way to use other launchers than mpirun and mpiexec,
 and for adding other options to the launcher. \\
 Examples (using bash) for openMPI and IBM Spectrum MPI: \\
 \verb|   export DALTON_LAUNCHER="mpirun -np 16 --map-by node"| \\
 \verb|   export DALTON_LAUNCHER="jsrun -n 12 -a 1 -c 4 -g 1 -bpacked:4"|
\end{list}

In most cases, the \verb|DALTON.OUT| file will contain all the
information needed about a given calculations. However, in certain
cases, additional information may be wanted, and this is contained
in various sets of auxiliary files. These files are copied back in the
tar'ed and gzip'ed archive file. This file may include the following set of
different files:

\begin{description}
\item[DALTON.BAS] Contains a dump of a complete molecule input file.
 This file take maximum
advantage of formatted input, yet differences may occur compared to
the basis sets obtained from the basis set library due to the
restricted number of digits available in the standard-format output.

\item[DALTON.CM] An output file that contains the most essential
information needed for calculation of shielding polarizabilities
and magnetizability polarizabilities. Most easily used together
with the analyzing program \verb|ODCPRG.f| supplied in
the\index{shielding polarizability}\index{magnetizability polarizability}\index{Cotton-Mouton}
tools directory.

\item[DALTON.HES] If the keyword \Key{HESPUN} has been specified in
the \Sec{VIBANA} input module, the molecular Hessian\index{Hessian}
will be written
to this file in a standard format, which may be used as a start Hessian
in an first-order\index{first-order optimization} geometry
optimization, or as input to a ROA  or
VCD\index{ROA}\index{Raman optical activity}\index{VCD}\index{vibrational circular dichroism}
analysis with different basis sets/level of correlation for the
intensity operators and the force field. See also the
\verb|FChk2HES.f| program in the tools directory.

\item[DALTON.IRC] Contains information obtained from an Intrinsic
Reaction Coordinate (IRC) calculation, as described in
Sec.~\ref{sec:irc}\index{IRC}\index{intrinsic reaction coordinate}.

\item[DALTON.MOL] Contains the information needed by the
\verb|MOLPLT|-program for visualizing the molecular geometry. The
\verb|MOLPLT|-program is distributed with the GAMESS-US program
package\index{MOLPLT}.

\item[DALTON.MOPUN] Contains the molecular-orbital coefficients
printed in a standard format allowing the transfer of molecular
orbitals coefficients from one computer to another.

\item[DALTON.NCA] Contains the information needed by the
\verb|MOLPLT|-program for visualizing normal coordinates\index{MOLPLT}.

\item[DALTON.ORB] Contains information about basis set and
MO-coefficients so that MO density plots may be generated using the
\verb|PLTORB| program that comes with the GAMESS-US
distribution. Currently not supported\index{PLTORB}.

\item[DALTON.TRJ] Contains trajectory information from a direct
dynamics calculation as described in
Sec.~\ref{sec:dynamic}\index{dynamics}.

\item[DALTON.WLK] Contains information from the walk-procedure, and is
needed when restarting a walk (e.g. a numerical differentiation).

\item[gv.off] Contains the information needed by the \verb|GEOMVIEW|
  program (\verb|http://www.geomview.org|) for visualizing the PCM
  cavity (see Section~\ref{sec:pcm})

\item[molden.inp] Contains the input required for visualizing the
  results of the calculation using the MOLDEN program
  (http://www.cmbi.ru.nl/molden/molden.html).

\item[pe\_*.bin] Files in binary format that can be used to restart a
  polarizable embedding calculation (see Chapter~\ref{ch:embedding}).

\item[RESULTS.RSP] Contains a brief summary of the results obtained
  form the response functions that have finished. The program may use
  this information to skip response equations that have already been
  solved (for instance if the calculation crashed for some reason
  during the calculation of a set of cubic response functions).

\item[RSPVEC] Contains the converged response equations. The program
  may use this to avoid repeating linear response equations. Thus, one
  may use the converged response vectors of a linear response equation
  in the calculation of quadratic response function, and there may
  then be no need to solve additional response equations.

\item[SIRIFC] Interface file between the wave function part of the
  program and the property modules. Contains all the information
  required about the optimized molecular wave function.

\item[SIRIUS.RST] Contains restart information needed in case one
  needs to restart the wave function part of the program.
\end{description}
